CD Actual 1/PC Actual CD 01.iso/f1/mdisk25.arj/MHELP.PAS

Pascal/Delphi Source File | 1994-08-31 | 19.3 KB | 850 lines

{************************************************}
{                                                }
{   Turbo Pascal 6.0                             }
{   Turbo Vision Demo                            }
{   Copyright (c) 1990 by Borland International  }
{                                                }
{************************************************}

{ Modificaciones del módulo HElp para su uso con MDiskpro }
{ modificaciones (c) Emilio David Diaus López 1994        }

Unit Mhelp;

{$F+,O+,X+,S-,D-,L-}

Interface

Uses Objects, Drivers, Views;

Const
  Chelpcolor      = #$17#$1F#$1E#$1B#$1B#$1E#$70#$7B;
  Chelpblackwhite = #$07#$0F#$07#$70#$70#$07#$0F#$70;
  Chelpmonochrome = #$07#$0F#$07#$70#$70#$07#$0F#$70;
  Chelpviewer     = #6#7#8;
  Chelpwindow     = #64#65#66#67#68#69#70#71;

Type

{ TParagraph }

  Pparagraph = ^Tparagraph;
  Tparagraph = Record
    Next: Pparagraph;
    Wrap: Boolean;
    Size: Word;
    Text: Record End;
  End;

{ THelpTopic }

  Tcrossref = Record
    Ref: Integer;
    Offset: Integer;
    Length: Byte;
  End;

  Pcrossrefs = ^Tcrossrefs;
  Tcrossrefs = Array[1..10000] Of Tcrossref;
  Tcrossrefhandler = Procedure (Var S: Tstream; Xrefvalue: Integer);

  Phelptopic = ^Thelptopic;
  Thelptopic = Object(Tobject)
    Constructor Init;
    Constructor Load(Var S: Tstream);
    Destructor Done; Virtual;
    Procedure Addcrossref(Ref: Tcrossref);
    Procedure Addparagraph(P: Pparagraph);
    Procedure Getcrossref(I: Integer; Var Loc: Tpoint; Var Length: Byte;
      Var Ref: Integer);
    Function Getline(Line: Integer): String;
    Function Getnumcrossrefs: Integer;
    Function Numlines: Integer;
    Procedure Setcrossref(I: Integer; Var Ref: Tcrossref);
    Procedure Setnumcrossrefs(I: Integer);
    Procedure Setwidth(Awidth: Integer);
    Procedure Store(Var S: Tstream);
  Private
    Paragraphs: Pparagraph;
    Numrefs: Integer;
    Crossrefs: Pcrossrefs;
    Width: Integer;
    Lastoffset: Integer;
    Lastline: Integer;
    Lastparagraph: Pparagraph;
    Function Wraptext(Var Text; Size: Integer; Var Offset: Integer;
      Wrap: Boolean): String;
  End;

{ THelpIndex }

  Pindexarray = ^Tindexarray;
  Tindexarray = Array[0..16380] Of Longint;

  Phelpindex = ^Thelpindex;
  Thelpindex = Object(Tobject)
    Size: Word;
    Index: Pindexarray;
    Constructor Init;
    Constructor Load(Var S: Tstream);
    Destructor Done; Virtual;
    Function Position(I: Integer): Longint;
    Procedure Add(I: Integer; Val: Longint);
    Procedure Store(Var S: Tstream);
  End;

{ THelpFile }

  Phelpfile = ^Thelpfile;
  Thelpfile = Object(Tobject)
    Stream: Pstream;
    Modified: Boolean;
    Constructor Init(S: Pstream);
    Destructor Done; Virtual;
    Function Gettopic(I: Integer): Phelptopic;
    Function Invalidtopic: Phelptopic;
    Procedure Recordpositioninindex(I: Integer);
    Procedure Puttopic(Topic: Phelptopic);
  Private
    Index: Phelpindex;
    Indexpos: Longint;
  End;

{ THelpViewer }

  Phelpviewer = ^Thelpviewer;
  Thelpviewer = Object(Tscroller)
    Hfile: Phelpfile;
    Topic: Phelptopic;
    Selected: Integer;
    Constructor Init(Var Bounds: Trect; Ahscrollbar,
      Avscrollbar: Pscrollbar; Ahelpfile: Phelpfile; Context: Word);
    Destructor Done; Virtual;
    Procedure Changebounds(Var Bounds: Trect); Virtual;
    Procedure Draw; Virtual;
    Function Getpalette: Ppalette; Virtual;
    Procedure Handleevent(Var Event: Tevent); Virtual;
  End;

{ THelpWindow }

  Phelpwindow = ^Thelpwindow;
  Thelpwindow = Object(Twindow)
    Constructor Init(Hfile: Phelpfile; Context: Word);
    Function Getpalette: Ppalette; Virtual;
  End;

Const

  Rhelptopic: Tstreamrec = (
     Objtype: 10000;
     Vmtlink: Ofs(Typeof(Thelptopic)^);
     Load:    @Thelptopic.Load;
     Store:   @Thelptopic.Store
  );
  Rhelpindex: Tstreamrec = (
     Objtype: 10001;
     Vmtlink: Ofs(Typeof(Thelpindex)^);
     Load:    @Thelpindex.Load;
     Store:   @Thelpindex.Store
  );

Procedure Registerhelpfile;

Procedure Notassigned(Var S: Tstream; Value: Integer);

Const
  Crossrefhandler: Tcrossrefhandler = Notassigned;

Implementation

{ THelpTopic }

Constructor Thelptopic.Init;
Begin
  Tobject.Init;
  Lastline := Maxint;
End;

Constructor Thelptopic.Load(Var S: Tstream);

Procedure Readparagraphs;
Var
  I, Size: Integer;
  Pp: ^Pparagraph;
Begin
  S.Read(I, Sizeof(I));
  Pp := @Paragraphs;
  While I > 0 Do
  Begin
    S.Read(Size, Sizeof(Size));
    Getmem(Pp^, Sizeof(Pp^^) + Size);
    Pp^^.Size := Size;
    S.Read(Pp^^.Wrap, Sizeof(Boolean));
    S.Read(Pp^^.Text, Size);
    Pp := @Pp^^.Next;
    Dec(I);
  End;
  Pp^ := Nil;
End;

Procedure Readcrossrefs;
Begin
  S.Read(Numrefs, Sizeof(Integer));
  Getmem(Crossrefs, Sizeof(Tcrossref) * Numrefs);
  S.Read(Crossrefs^, Sizeof(Tcrossref) * Numrefs);
End;

Begin
  Readparagraphs;
  Readcrossrefs;
  Width := 0;
  Lastline := Maxint;
End;

Destructor Thelptopic.Done;

Procedure Disposeparagraphs;
Var
  P, T: Pparagraph;
Begin
  P := Paragraphs;
  While P <> Nil Do
  Begin
    T := P;
    P := P^.Next;
    Freemem(T, Sizeof(T^) + T^.Size);
  End;
End;

Begin
  Disposeparagraphs;
  Freemem(Crossrefs, Sizeof(Tcrossref) * Numrefs);
  Tobject.Done
End;

Procedure Thelptopic.Addcrossref(Ref: Tcrossref);
Var
  P: Pcrossrefs;
Begin
  Getmem(P, (Numrefs+1) * Sizeof(Tcrossref));
  If Numrefs > 0 Then
  Begin
    Move(Crossrefs^, P^, Numrefs * Sizeof(Tcrossref));
    Freemem(Crossrefs, Numrefs * Sizeof(Tcrossref));
  End;
  Crossrefs^[Numrefs] := Ref;
  Inc(Numrefs);
End;

Procedure Thelptopic.Addparagraph(P: Pparagraph);
Var
  Pp: ^Pparagraph;
Begin
  Pp := @Paragraphs;
  While Pp^ <> Nil Do
    Pp := @Pp^^.Next;
  Pp^ := P;
  P^.Next := Nil;
End;

Procedure Thelptopic.Getcrossref(I: Integer; Var Loc: Tpoint;
  Var Length: Byte; Var Ref: Integer);
Var
  Oldoffset, Curoffset, Offset, Paraoffset: Integer;
  P: Pparagraph;
  Line: Integer;
Begin
  Paraoffset := 0;
  Curoffset := 0;
  Oldoffset := 0;
  Line := 0;
  Offset := Crossrefs^[I].Offset;
  P := Paragraphs;
  While Paraoffset+Curoffset < Offset Do
  Begin
    Oldoffset := Paraoffset + Curoffset;
    Wraptext(P^.Text, P^.Size, Curoffset, P^.Wrap);
    Inc(Line);
    If Curoffset >= P^.Size Then
    Begin
      Inc(Paraoffset, P^.Size);
      P := P^.Next;
      Curoffset := 0;
    End;
  End;
  Loc.X := Offset - Oldoffset - 1;
  Loc.Y := Line;
  Length := Crossrefs^[I].Length;
  Ref := Crossrefs^[I].Ref;
End;

Function Thelptopic.Getline(Line: Integer): String;
Var
  Offset, I: Integer;
  P: Pparagraph;
Begin
  If Lastline < Line Then
  Begin
    I := Line;
    Dec(Line, Lastline);
    Lastline := I;
    Offset := Lastoffset;
    P := Lastparagraph;
  End
  Else
  Begin
    P := Paragraphs;
    Offset := 0;
    Lastline := Line;
  End;
  Getline := '';
  While (P <> Nil) Do
  Begin
    While Offset < P^.Size Do
    Begin
      Dec(Line);
      Getline := Wraptext(P^.Text, P^.Size, Offset, P^.Wrap);
      If Line = 0 Then
      Begin
        Lastoffset := Offset;
        Lastparagraph := P;
        Exit;
      End;
    End;
    P := P^.Next;
    Offset := 0;
  End;
  Getline := '';
End;

Function Thelptopic.Getnumcrossrefs: Integer;
Begin
  Getnumcrossrefs := Numrefs;
End;

Function Thelptopic.Numlines: Integer;
Var
  Offset, Lines: Integer;
  P: Pparagraph;
Begin
  Offset := 0;
  Lines := 0;
  P := Paragraphs;
  While P <> Nil Do
  Begin
    Offset := 0;
    While Offset < P^.Size Do
    Begin
      Inc(Lines);
      Wraptext(P^.Text, P^.Size, Offset, P^.Wrap);
    End;
    P := P^.Next;
  End;
  Numlines := Lines;
End;

Procedure Thelptopic.Setcrossref(I: Integer; Var Ref: Tcrossref);
Begin
  If I <= Numrefs Then Crossrefs^[I] := Ref;
End;

Procedure Thelptopic.Setnumcrossrefs(I: Integer);
Var
  P: Pcrossrefs;
Begin
  If Numrefs = I Then Exit;
  Getmem(P, I * Sizeof(Tcrossref));
  If Numrefs > 0 Then
  Begin
    If I > Numrefs Then Move(Crossrefs^, P^, Numrefs * Sizeof(Tcrossref))
    Else Move(Crossrefs^, P^, I * Sizeof(Tcrossref));
    Freemem(Crossrefs, Numrefs * Sizeof(Tcrossref));
  End;
  Crossrefs := P;
  Numrefs := I;
End;

Procedure Thelptopic.Setwidth(Awidth: Integer);
Begin
  Width := Awidth;
End;

Procedure Thelptopic.Store(Var S: Tstream);

Procedure Writeparagraphs;
Var
  I: Integer;
  P: Pparagraph;
Begin
  P := Paragraphs;
  I := 0;
  While P <> Nil Do
  Begin
    Inc(I);
    P := P^.Next;
  End;
  S.Write(I, Sizeof(I));
  P := Paragraphs;
  While P <> Nil Do
  Begin
    S.Write(P^.Size, Sizeof(Integer));
    S.Write(P^.Wrap, Sizeof(Boolean));
    S.Write(P^.Text, P^.Size);
    P := P^.Next;
  End;
End;

Procedure Writecrossrefs;
Var
  I: Integer;
Begin
  S.Write(Numrefs, Sizeof(Integer));
  If @Crossrefhandler = @Notassigned Then
    S.Write(Crossrefs^, Sizeof(Tcrossref) * Numrefs)
  Else
    For I := 1 To Numrefs Do
    Begin
      Crossrefhandler(S, Crossrefs^[I].Ref);
      S.Write(Crossrefs^[I].Offset, Sizeof(Integer) + Sizeof(Byte));
    End;
End;

Begin
  Writeparagraphs;
  Writecrossrefs;
End;

Function Thelptopic.Wraptext(Var Text; Size: Integer;
  Var Offset: Integer; Wrap: Boolean): String;
Type
  Pcarray = ^Carray;
  Carray = Array[0..32767] Of Char;
Var
  Line: String;
  I, P: Integer;

Function Isblank(Ch: Char): Boolean;
Begin
  Isblank := (Ch = ' ') Or (Ch = #13) Or (Ch = #10);
End;

Function Scan(Var P; Offset: Integer; C: Char): Integer; Assembler;
Asm
    Cld
    Les    Di,p
        Add    Di,&Offset
    Mov    Cx,256
    Mov    Al, c
        Repne    Scasb
    Sub    Cx,256
        Neg    Cx
        Xchg    Ax,Cx
End;

Procedure Texttoline(Var Text; Offset, Length: Integer; Var Line: String);
  Assembler;
Asm
    Cld
    Push    Ds
    Lds    Si,Text
        Add    Si,&Offset
        Les     Di,Line
        Mov    Ax,Length
        Stosb
        Xchg    Ax,Cx
        Rep    Movsb
        Pop    Ds
End;

Begin
  I := Scan(Text, Offset, #13);
  If I + Offset > Size Then I := Size - Offset;
  If (I >= Width) And Wrap Then
  Begin
    I := Offset + Width;
    If I > Size Then I := Size
    Else
    Begin
      While (I > Offset) And Not Isblank(Pcarray(@Text)^[I]) Do Dec(I);
      If I = Offset Then I := Offset + Width
      Else Inc(I);
    End;
    If I = Offset Then I := Offset + Width;
    Dec(I, Offset);
  End;
  Texttoline(Text, Offset, I, Line);
  If Line[Length(Line)] = #13 Then Dec(Line[0]);
  Inc(Offset, I);
  Wraptext := Line;
End;

{ THelpIndex }

Constructor Thelpindex.Init;
Begin
  Tobject.Init;
  Size := 0;
  Index := Nil;
End;

Constructor Thelpindex.Load(Var S: Tstream);
Begin
  S.Read(Size, Sizeof(Size));
  If Size = 0 Then Index := Nil
  Else
  Begin
    Getmem(Index, Sizeof(Longint) * Size);
    S.Read(Index^, Sizeof(Longint) * Size);
  End;
End;

Destructor Thelpindex.Done;
Begin
  Freemem(Index, Sizeof(Longint) * Size);
  Tobject.Done;
End;

Function Thelpindex.Position(I: Integer): Longint;
Begin
  If I < Size Then Position := Index^[I]
  Else Position := -1;
End;

Procedure Thelpindex.Add(I: Integer; Val: Longint);
Const
  Delta = 10;
Var
  P: Pindexarray;
  Newsize: Integer;
Begin
  If I >= Size Then
  Begin
    Newsize := (I + Delta) Div Delta * Delta;
    Getmem(P, Newsize * Sizeof(Longint));
    If P <> Nil Then
    Begin
      Move(Index^, P^, Size * Sizeof(Longint));
      Fillchar(P^[Size], (Newsize - Size) * Sizeof(Longint), $Ff);
    End;
    If Size > 0 Then Freemem(Index, Size * Sizeof(Longint));
    Index := P;
    Size := Newsize;
  End;
  Index^[I] := Val;
End;

Procedure Thelpindex.Store(Var S: Tstream);
Begin
  S.Write(Size, Sizeof(Size));
  S.Write(Index^, Sizeof(Longint) * Size);
End;

{ THelpFile }

Const
  Magicheader = $46484246; {'Fbhf'}

Constructor Thelpfile.Init(S: Pstream);
Var
  Magic: Longint;
Begin
  Magic := 0;
  S^.Seek(0);
  If S^.Getsize > Sizeof(Magic) Then
    S^.Read(Magic, Sizeof(Magic));
  If Magic <> Magicheader Then
  Begin
    Indexpos := 12;
    S^.Seek(Indexpos);
    Index := New(Phelpindex, Init);
    Modified := True;
  End
  Else
  Begin
    S^.Seek(8);
    S^.Read(Indexpos, Sizeof(Indexpos));
    S^.Seek(Indexpos);
    Index := Phelpindex(S^.Get);
    Modified := False;
  End;
  Stream := S;
End;

Destructor Thelpfile.Done;
Var
  Magic, Size: Longint;
Begin
  If Modified Then
  Begin
    Stream^.Seek(Indexpos);
    Stream^.Put(Index);
    Stream^.Seek(0);
    Magic := Magicheader;
    Size := Stream^.Getsize - 8;
    Stream^.Write(Magic, Sizeof(Magic));
    Stream^.Write(Size, Sizeof(Size));
    Stream^.Write(Indexpos, Sizeof(Indexpos));
  End;
  Dispose(Stream, Done);
  Dispose(Index, Done);
End;

Function Thelpfile.Gettopic(I: Integer): Phelptopic;
Var
  Pos: Longint;
Begin
  Pos := Index^.Position(I);
  If Pos > 0 Then
  Begin
    Stream^.Seek(Pos);
    Gettopic := Phelptopic(Stream^.Get);
  End
  Else Gettopic := Invalidtopic;
End;

Function Thelpfile.Invalidtopic: Phelptopic;
Var
  Topic: Phelptopic;
  Para: Pparagraph;
Const
  Invalidstr = #13' Ayuda no disponible en este contexto.';
  Invalidtext: Array[1..Length(Invalidstr)] Of Char = Invalidstr;
Begin
  Topic := New(Phelptopic, Init);
  Getmem(Para, Sizeof(Para^) + Sizeof(Invalidtext));
  Para^.Size := Sizeof(Invalidtext);
  Para^.Wrap := False;
  Para^.Next := Nil;
  Move(Invalidtext, Para^.Text, Sizeof(Invalidtext));
  Topic^.Addparagraph(Para);
  Invalidtopic := Topic;
End;

Procedure Thelpfile.Recordpositioninindex(I: Integer);
Begin
  Index^.Add(I, Indexpos);
  Modified := True;
End;

Procedure Thelpfile.Puttopic(Topic: Phelptopic);
Begin
  Stream^.Seek(Indexpos);
  Stream^.Put(Topic);
  Indexpos := Stream^.Getpos;
  Modified := True;
End;

{ THelpViewer }

Constructor Thelpviewer.Init(Var Bounds: Trect; Ahscrollbar,
  Avscrollbar: Pscrollbar; Ahelpfile: Phelpfile; Context: Word);
Begin
  Tscroller.Init(Bounds, Ahscrollbar, Avscrollbar);
  Options := Options Or Ofselectable;
  Growmode := Gfgrowhix + Gfgrowhiy;
  Hfile := Ahelpfile;
  Topic := Ahelpfile^.Gettopic(Context);
  Topic^.Setwidth(Size.X);
  Setlimit(78, Topic^.Numlines);
  Selected := 1;
End;

Destructor Thelpviewer.Done;
Begin
  Tscroller.Done;
  Dispose(Hfile, Done);
  Dispose(Topic, Done);
End;

Procedure Thelpviewer.Changebounds(Var Bounds: Trect);
Begin
  Tscroller.Changebounds(Bounds);
  Topic^.Setwidth(Size.X);
  Setlimit(Limit.X, Topic^.Numlines);
End;

Procedure Thelpviewer.Draw;
Var
  B: Tdrawbuffer;
  Line: String;
  I, J, L: Integer;
  Keycount: Integer;
  Normal, Keyword, Selkeyword, C: Byte;
  Keypoint: Tpoint;
  Keylength: Byte;
  Keyref: Integer;
Begin
  Normal := Getcolor(1);
  Keyword := Getcolor(2);
  Selkeyword := Getcolor(3);
  Keycount := 0;
  Keypoint.X := 0;
  Keypoint.Y := 0;
  Topic^.Setwidth(Size.X);
  If Topic^.Getnumcrossrefs > 0 Then
    Repeat
      Inc(Keycount);
      Topic^.Getcrossref(Keycount, Keypoint, Keylength, Keyref);
    Until (Keycount >= Topic^.Getnumcrossrefs) Or (Keypoint.Y > Delta.Y);
  For I := 1 To Size.Y Do
  Begin
    Movechar(B, ' ', Normal, Size.X);
    Line := Topic^.Getline(I + Delta.Y);
    Movestr(B, Copy(Line, Delta.X+1, Size.X), Normal);
    While I + Delta.Y = Keypoint.Y Do
    Begin
      L := Keylength;
      If Keypoint.X < Delta.X Then
      Begin
        Dec(L, Delta.X - Keypoint.X);
        Keypoint.X := Delta.X;
      End;
      If Keycount = Selected Then C := Selkeyword
      Else C := Keyword;
      For J := 0 To L-1 Do
        Wordrec(B[Keypoint.X - Delta.X + J]).Hi := C;
      Inc(Keycount);
      If Keycount <= Topic^.Getnumcrossrefs Then
        Topic^.Getcrossref(Keycount, Keypoint, Keylength, Keyref)
      Else Keypoint.Y := 0;
    End;
    Writeline(0, I-1, Size.X, 1, B);
  End;
End;

Function Thelpviewer.Getpalette: Ppalette;
Const
  P: String[Length(Chelpviewer)] = Chelpviewer;
Begin
  Getpalette := @P;
End;

Procedure Thelpviewer.Handleevent(Var Event: Tevent);
Var
  Keypoint, Mouse: Tpoint;
  Keylength: Byte;
  Keyref: Integer;
  Keycount: Integer;

Procedure Makeselectvisible;
Var
  D: Tpoint;
Begin
  Topic^.Getcrossref(Selected, Keypoint, Keylength, Keyref);
  D := Delta;
  If Keypoint.X < D.X Then D.X := Keypoint.X;
  If Keypoint.X > D.X + Size.X Then D.X := Keypoint.X - Size.X;
  If Keypoint.Y < D.Y Then D.Y := Keypoint.Y;
  If Keypoint.Y > D.Y + Size.Y Then D.Y := Keypoint.Y - Size.Y;
  If (D.X <> Delta.X) Or (D.Y <> Delta.Y) Then Scrollto(D.X, D.Y);
End;

Procedure Switchtotopic(Keyref: Integer);
Begin
  If Topic <> Nil Then Dispose(Topic, Done);
  Topic := Hfile^.Gettopic(Keyref);
  Topic^.Setwidth(Size.X);
  Scrollto(0, 0);
  Setlimit(Limit.X, Topic^.Numlines);
  Selected := 1;
  Drawview;
End;

Begin
  Tscroller.Handleevent(Event);
  Case Event.What Of
    Evkeydown:
      Begin
        Case Event.Keycode Of
          Kbtab:
            Begin
              Inc(Selected);
              If Selected > Topic^.Getnumcrossrefs Then Selected := 1;
              Makeselectvisible;
            End;
          Kbshifttab:
            Begin
              Dec(Selected);
              If Selected = 0 Then Selected := Topic^.Getnumcrossrefs;
              Makeselectvisible;
            End;
          Kbenter:
            Begin
              If Selected <= Topic^.Getnumcrossrefs Then
              Begin
                Topic^.Getcrossref(Selected, Keypoint, Keylength, Keyref);
                Switchtotopic(Keyref);
              End;
            End;
          Kbesc:
            Begin
              Event.What := Evcommand;
              Event.Command := Cmclose;
              Putevent(Event);
            End;
        Else
          Exit;
        End;
        Drawview;
        Clearevent(Event);
      End;
    Evmousedown:
      Begin
        Makelocal(Event.Where, Mouse);
        Inc(Mouse.X, Delta.X); Inc(Mouse.Y, Delta.Y);
        Keycount := 0;
        Repeat
          Inc(Keycount);
          If Keycount > Topic^.Getnumcrossrefs Then Exit;
          Topic^.Getcrossref(Keycount, Keypoint, Keylength, Keyref);
        Until (Keypoint.Y = Mouse.Y+1) And (Mouse.X >= Keypoint.X) And
          (Mouse.X < Keypoint.X + Keylength);
        Selected := Keycount;
        Drawview;
        If Event.Double Then Switchtotopic(Keyref);
        Clearevent(Event);
      End;
    Evcommand:
      If (Event.Command = Cmclose) And (Owner^.State And Sfmodal <> 0) Then
      Begin
        Endmodal(Cmclose);
        Clearevent(Event);
      End;
  End;
End;

{ THelpWindow }

Constructor Thelpwindow.Init(Hfile: Phelpfile; Context: Word);
Var
  R: Trect;
Begin
  R.Assign(0, 0, 50, 18);
  Twindow.Init(R, 'Ayuda', Wnnonumber);
  Options := Options Or Ofcentered;
  R.Grow(-2,-1);
  Insert(New(Phelpviewer, Init(R,
    Standardscrollbar(Sbhorizontal + Sbhandlekeyboard),
    Standardscrollbar(Sbvertical + Sbhandlekeyboard), Hfile, Context)));
End;

Function Thelpwindow.Getpalette: Ppalette;
Const
  P: String[Length(Chelpwindow)] = Chelpwindow;
Begin
  Getpalette := @P;
End;

Procedure Registerhelpfile;
Begin
  Registertype(Rhelptopic);
  Registertype(Rhelpindex);
End;

Procedure Notassigned(Var S: Tstream; Value: Integer);
Begin
End;

End.